#
#include "event.h"

Event &Event::getInstance()
{
    static Event instance;
    return instance;
}
void Event::on(Callback callback)
{
    this->_listeners.push_back(callback);
}
void Event::emit()
{
    for (auto &listener : this->_listeners)
    {
        listener();
    }

}

// template< typename EventType,typename T>
// void Event::on(const std::string &eventName, EventHandlerFunc<EventType> listener, const T *instance){
//     std::lock_guard<std::mutex> lock(mutex);

//     auto &typeHandlers = handlers[typeid(EventType)];
//     if (typeHandlers.find(eventName) == typeHandlers.end())
//     {
//         typeHandlers[eventName] = std::vector<EventHandler>();
//     }
//     auto &handlers = typeHandlers[eventName];
//     handlers.emplace_back(
//         EventHandler{
//             instance,
//             listener});

// }

// template <typename EventType>
// void Event::on(const std::string &eventName, const std::string &className, EventHandlerFunc<EventType> listener)
// {
//     std::lock_guard<std::mutex> lock(mutex);

//     handlers[typeid(EventType)][eventName].emplace_back(
//         EventHandler{
//             className,
//             [listener](const void *event)
//             {
//                 listener(*static_cast<const EventType *>(event));
//             }});
// }

// template <typename EventType>
// void Event::emit(const std::string &eventName, const EventType &event)
// {
//     std::vector<EventHandler> listeners;
//     {
//         std::lock_guard<std::mutex> lock(mutex);
//         auto typeIt = handlers.find(typeid(EventType));
//         if (typeIt != handlers.end())
//         {
//             auto nameIt = typeIt->second.find(eventName);
//             if (nameIt != typeIt->second.end())
//             {
//                 listeners = nameIt->second;
//             }
//         }
//     }

//     for (auto &handler : listeners)
//     {
//         handler.callback(&event);
//     }
// }
// void Event::remove(const std::string &className)
// {
//     std::lock_guard<std::mutex> lock(mutex);

//     for (auto &typePair : handlers)
//     {
//         for (auto &namePair : typePair.second)
//         {
//             auto &handlers = namePair.second;
//             handlers.erase(
//                 std::remove_if(handlers.begin(), handlers.end(),
//                                [&className](const EventHandler &h)
//                                {
//                                    return h.className == className;
//                                }),
//                 handlers.end());
//         }
//     }
// }

// // 自定义事件类型
// struct MyEvent {
//     int value;
//     std::string message;
// };

// int main() {
//     // 订阅事件
//     Event::getInstance().on<MyEvent>([](const MyEvent& e) {
//         std::cout << "Received: " << e.value << ", " << e.message << std::endl;
//     });

//     // 发布事件
//     Event::getInstance().emit(MyEvent{42, "Hello World"});

//     return 0;
// }